package com.mindskip.xzs.service.impl;
//这段代码是任务考试管理模块的业务逻辑实现部分
//创建任务考试记录：根据前端传入的视图模型，将任务考试记录保存到数据库中，并关联试卷的taskId。
//将任务考试记录转换为视图模型：根据传入的任务考试记录id，查询任务考试记录并将其转换为视图模型，包括任务考试记录的基本信息、限时时间、试卷信息等。
//根据年级级别获取任务考试列表：根据传入的年级级别，查询符合条件的任务考试记录列表。
//获取所有任务考试列表：查询数据库中所有的任务考试记录列表。
//根据任务ID列表获取任务考试列表：根据传入的任务ID列表，查询对应的任务考试记录列表。
//这段代码主要作用于任务考试管理模块，实现了任务考试记录的创建、查询和转换为视图模型等功能，供前端页面展示和操作使用。
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.IPage;
import com.github.pagehelper.Page;
import com.mindskip.xzs.domain.*;
import com.mindskip.xzs.domain.task.TaskItemObject;
import com.mindskip.xzs.repository.BatchMapper;
import com.mindskip.xzs.repository.BatchTaskMapper;
import com.mindskip.xzs.repository.ExamPaperMapper;
import com.mindskip.xzs.repository.TaskExamMapper;
import com.mindskip.xzs.service.BatchTaskServer;
import com.mindskip.xzs.service.TaskExamService;
import com.mindskip.xzs.service.TextContentService;
import com.mindskip.xzs.service.enums.ActionEnum;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.JsonUtil;
import com.mindskip.xzs.utility.ModelMapperSingle;
import com.mindskip.xzs.viewmodel.admin.exam.ExamResponseVM;
import com.mindskip.xzs.viewmodel.admin.task.TaskPageRequestVM;
import com.mindskip.xzs.viewmodel.admin.task.TaskRequestVM;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

@Service // 标识为服务类
public class TaskExamServiceImpl extends BaseServiceImpl<TaskExam> implements TaskExamService {

    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance(); // 初始化ModelMapper实例
    private final TaskExamMapper taskExamMapper; // TaskExamMapper对象
    private final TextContentService textContentService; // 文本内容服务对象
    private final ExamPaperMapper examPaperMapper; // 考试卷Mapper对象

    @Autowired // 自动注入依赖
    public TaskExamServiceImpl(TaskExamMapper taskExamMapper, TextContentService textContentService, ExamPaperMapper examPaperMapper) {
        super(taskExamMapper); // 调用父类构造方法
        this.taskExamMapper = taskExamMapper;
        this.textContentService = textContentService;
        this.examPaperMapper = examPaperMapper;
    }

    @Resource // 资源注入
    private BatchTaskServer batchTaskServer;
    @Resource
    private BatchMapper batchMapper;

    @Override
    public PageInfo<TaskExam> page(TaskPageRequestVM requestVM) {
        // 分页查询任务考试列表
        return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
                taskExamMapper.page(requestVM)
        );
    }

    @Override
    @Transactional // 事务管理
    public void edit(TaskRequestVM model, User user) {
        ActionEnum actionEnum = (model.getId() == null) ? ActionEnum.ADD : ActionEnum.UPDATE; // 判断操作类型（新增或更新）
        TaskExam taskExam = null;
        if (actionEnum == ActionEnum.ADD) { // 新增操作
            Date now = new Date(); // 当前时间
            taskExam = modelMapper.map(model, TaskExam.class); // 映射到TaskExam对象
            taskExam.setCreateUser(user.getId()); // 设置创建用户ID
            taskExam.setCreateUserName(user.getUserName()); // 设置创建用户名
            taskExam.setLimitStartTime(DateTimeUtil.parse(model.getLimitDateTime().get(0), DateTimeUtil.STANDER_FORMAT)); // 设置开始时间
            taskExam.setLimitEndTime(DateTimeUtil.parse(model.getLimitDateTime().get(1),DateTimeUtil.STANDER_FORMAT)); // 设置结束时间
            taskExam.setCreateTime(now); // 设置创建时间
            taskExam.setDeleted(false); // 设置未删除状态

            // 保存任务结构
            TextContent textContent = textContentService.jsonConvertInsert(model.getPaperItems(), now, p -> {
                TaskItemObject taskItemObject = new TaskItemObject();
                taskItemObject.setExamPaperId(p.getId());
                taskItemObject.setExamPaperName(p.getName());
                return taskItemObject;
            });
            textContentService.insertByFilter(textContent); // 插入文本内容
            taskExam.setFrameTextContentId(textContent.getId()); // 设置文本内容ID
            taskExamMapper.insertSelective(taskExam); // 插入任务考试记录

        } else { // 更新操作
            taskExam = taskExamMapper.selectByPrimaryKey(model.getId()); // 查找任务考试记录
            modelMapper.map(model, taskExam); // 映射更新属性
            taskExam.setLimitStartTime(DateTimeUtil.parse(model.getLimitDateTime().get(0), DateTimeUtil.STANDER_FORMAT)); // 设置开始时间
            taskExam.setLimitEndTime(DateTimeUtil.parse(model.getLimitDateTime().get(1),DateTimeUtil.STANDER_FORMAT)); // 设置结束时间
            TextContent textContent = textContentService.selectById(taskExam.getFrameTextContentId()); // 查找文本内容
            // 清空试卷任务的试卷Id，后面会统一设置
            List<Integer> paperIds = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class)
                    .stream()
                    .map(d -> d.getExamPaperId())
                    .collect(Collectors.toList());
            examPaperMapper.clearTaskPaper(paperIds); // 清空试卷任务

            // 更新任务结构
            textContentService.jsonConvertUpdate(textContent, model.getPaperItems(), p -> {
                TaskItemObject taskItemObject = new TaskItemObject();
                taskItemObject.setExamPaperId(p.getId());
                taskItemObject.setExamPaperName(p.getName());
                return taskItemObject;
            });
            textContentService.updateByIdFilter(textContent); // 更新文本内容
            taskExamMapper.updateByPrimaryKeySelective(taskExam); // 更新任务考试记录
        }

        // 更新试卷的taskId
        List<Integer> paperIds = model.getPaperItems().stream().map(d -> d.getId()).collect(Collectors.toList());
        examPaperMapper.updateTaskPaper(taskExam.getId(), paperIds); // 更新试卷任务ID
        model.setId(taskExam.getId());
    }

    @Override
    public TaskRequestVM taskExamToVM(Integer id) {
        TaskExam taskExam = taskExamMapper.selectByPrimaryKey(id); // 查找任务考试记录
        TaskRequestVM vm = modelMapper.map(taskExam, TaskRequestVM.class); // 映射到视图模型
        TextContent textContent = textContentService.selectById(taskExam.getFrameTextContentId()); // 查找文本内容
        // 转换为视图模型
        List<ExamResponseVM> examResponseVMS = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class).stream().map(tk -> {
            ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(tk.getExamPaperId()); // 查找考试卷
            ExamResponseVM examResponseVM = modelMapper.map(examPaper, ExamResponseVM.class); // 映射到视图模型
            examResponseVM.setCreateTime(DateTimeUtil.dateFormat(examPaper.getCreateTime())); // 设置创建时间
            return examResponseVM;
        }).collect(Collectors.toList());
        List<String> limitDateTime=new LinkedList<>();
        limitDateTime.add(DateTimeUtil.dateFormat(taskExam.getLimitStartTime())); // 设置开始时间
        limitDateTime.add(DateTimeUtil.dateFormat(taskExam.getLimitEndTime())); // 设置结束时间
        vm.setLimitDateTime(limitDateTime);
        vm.setPaperItems(examResponseVMS);
        return vm;
    }

    @Override
    public List<TaskExam> getByGradeLevel(Integer gradeLevel) {
        return taskExamMapper.getByGradeLevel(gradeLevel); // 根据年级级别获取任务考试列表
    }

    @Override
    public List<TaskExam> getTaskExamAll() {
        return taskExamMapper.getTaskExamAll(); // 获取所有任务考试列表
    }

    @Override
    public List<TaskExam> getTaskExamAllByTaskIds(List<Integer> taskIds) {
        return this.taskExamMapper.getTaskExamAllByTaskIds(taskIds); // 根据任务ID列表获取任务考试列表
    }

}
